Object Detection via Semantic Segmentation¶
Import Modules¶
In [1]:
# IMPORT MODULES
# Import Import Numpy, TensorFlow, Scipy, Keras
import sys
import time
import os
import numpy as np
import pandas as pd
from glob import glob
import cv2
import matplotlib.pyplot as plt
from skimage.segmentation import mark_boundaries
import pickle
import math
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from scipy.signal import find_peaks_cwt
import random
from sklearn.utils import shuffle
import csv
import tensorflow as tf
from tensorflow.contrib.layers import flatten
from tensorflow.examples.tutorials.mnist import input_data
import keras
from keras.datasets import cifar10
from keras.models import Sequential,model_from_json
from keras.layers import Dense,Dropout,Activation,Flatten
from keras.layers import Convolution2D,MaxPooling2D
from keras.layers import Flatten,Lambda,ELU
from keras.optimizers import SGD,Adam,RMSprop
from keras.layers.convolutional import Conv2D
from keras.layers.normalization import BatchNormalization
from keras.utils import np_utils
from keras.preprocessing.image import ImageDataGenerator
from keras.initializers import glorot_uniform
from sklearn.cross_validation import train_test_split
import scipy.misc
from matplotlib.pyplot import imshow
%matplotlib inline
from IPython.display import SVG
import json
from keras.models import Sequential, model_from_json
print('Import Modules')
Load Data¶
In [2]:
# LOAD DATA
# Change Directory
os.chdir('..')
In [3]:
# LOAD DATA
# Find Files
all_paths = pd.DataFrame(dict(Path = glob(os.path.join('Data','*', '*.*p*g'))))
all_paths['Split'] = all_paths['Path'].map(lambda x: x.split('/')[-2].split('-')[0])
all_paths['Group'] = all_paths['Path'].map(lambda x: x.split('/')[-2].split('-')[-1])
all_paths['ID'] = all_paths['Path'].map(lambda x: '_'.join(os.path.splitext(os.path.basename(x))[0].split('_')[:4]))
In [4]:
# LOAD DATA
# Display Samples
all_paths.sample(5)
Out[4]:
In [5]:
# LOAD DATA
# Pivot Data
group_df = all_paths.pivot_table(values = 'Path', columns = 'Group', \
aggfunc = 'first', index = ['ID', 'Split']).reset_index()
In [6]:
# LOAD DATA
# Display Samples
group_df.sample(5)
Out[6]:
In [7]:
# LOAD DATA
# Load Training Data Files
training_data_files = group_df.query('Split=="Train"')
data_size = training_data_files.shape[0]
print('Size of Training Data', data_size)
Explore Data¶
In [8]:
# EXPLORE DATA
# Load Images in Loop and Display
for i in range(1020,1030):
# Load Images
input_img = cv2.imread(training_data_files['Color'][i])
label_img = cv2.imread(training_data_files['Label'][i])
# Crop
input_img = input_img[1200:2400,:]
label_img = label_img[1200:2400,:]
# Convert to Grayscale
label_img = cv2.cvtColor(label_img, cv2.COLOR_RGB2GRAY)
# Resize Image to 100x100
input_img = cv2.resize(input_img, (560, 200))
label_img = cv2.resize(label_img, (560, 200))
# Plot
fig,(axis1,axis2)=plt.subplots(1,2,figsize=(15,15))
axis1.imshow(input_img)
axis1.set_title('Image',fontsize=7.5)
axis2.imshow(label_img)
axis2.set_title('Label',fontsize=7.5)
Preprocess Data¶
In [9]:
# PREPROCESS DATA
# Clear Memory
del all_paths
del group_df
In [10]:
# PREPROCESS DATA
# Load Input Images
x_train = []
for i in range(10000):
# Load Images
input_img = cv2.imread(training_data_files['Color'][i])
# Crop
input_img = input_img[1200:2400,:]
# Resize Image to 100x280
input_img = cv2.resize(input_img, (288, 288))
# Flatten Image and Append
image_flat = input_img.flatten().tolist()
x_train += image_flat
# Check Progress
if (i%100 == 0):
print('Images Loaded:', i)
# Check Size of Data
image_feature_size=int(len(x_train))
print("Feature Size:", image_feature_size)
# Revert to the Original Image Shapes
x_train = np.array(x_train).reshape(10000, 288, 288, 3)
print("Feature Size:", x_train.shape)
In [11]:
# PREPROCESS DATA
# Load Label Images
y_train = []
for i in range(10000):
# Load Images
label_img = cv2.imread(training_data_files['Label'][i])
# Crop
label_img = label_img[1200:2400,:]
# Convert to Grayscale
label_img = cv2.cvtColor(label_img, cv2.COLOR_RGB2GRAY)
# Resize Image to 100x280
label_img = cv2.resize(label_img, (288, 288))
# Flatten Image and Append
label_flat = label_img.flatten().tolist()
y_train += label_flat
# Check Progress
if (i%100 == 0):
print('Images Loaded:', i)
# Check Size of Data
label_feature_size=int(len(y_train))
print("Feature Size:", label_feature_size)
# Revert to the Original Image Shapes
y_train = np.array(y_train).reshape(10000, 288, 288, 1)
print("Feature Size:", y_train.shape)
In [12]:
# PREPROCESS DATA
# Load Input Images
x_valid = []
for i in range(2000):
# Load Images
input_img = cv2.imread(training_data_files['Color'][i])
# Crop
input_img = input_img[1200:2400,:]
# Resize Image to 100x280
input_img = cv2.resize(input_img, (288, 288))
# Flatten Image and Append
image_flat = input_img.flatten().tolist()
x_valid += image_flat
# Check Progress
if (i%100 == 0):
print('Images Loaded:', i)
# Check Size of Data
image_feature_size=int(len(x_valid))
print("Feature Size:", image_feature_size)
# Revert to the Original Image Shapes
x_valid = np.array(x_valid).reshape(2000, 288, 288, 3)
print("Feature Size:", x_valid.shape)
In [13]:
# PREPROCESS DATA
# Load Label Images
y_valid = []
for i in range(2000):
# Load Images
label_img = cv2.imread(training_data_files['Label'][i])
# Crop
label_img = label_img[1200:2400,:]
# Convert to Grayscale
label_img = cv2.cvtColor(label_img, cv2.COLOR_RGB2GRAY)
# Resize Image to 100x280
label_img = cv2.resize(label_img, (288, 288))
# Flatten Image and Append
label_flat = label_img.flatten().tolist()
y_valid += label_flat
# Check Progress
if (i%100 == 0):
print('Images Loaded:', i)
# Check Size of Data
label_feature_size=int(len(y_valid))
print("Feature Size:", label_feature_size)
# Revert to the Original Image Shapes
y_valid = np.array(y_valid).reshape(2000, 288, 288, 1)
print("Feature Size:", y_valid.shape)
In [14]:
# PREPROCESS DATA
# Clear Memory
del training_data_files
Create Model¶
In [15]:
# CREATE MODEL
# Import Modules
from keras.models import Model, load_model
from keras.layers import Input, BatchNormalization, Dropout, Lambda
from keras.layers.convolutional import Conv2D, Conv2DTranspose
from keras.layers.pooling import MaxPooling2D
from keras.layers.merge import concatenate
from keras.layers import UpSampling2D
import time
from skimage import data, color
from skimage.transform import rescale, resize, downscale_local_mean
# Define a Function for Convolutional Block
def conv2d_block(input_tensor, n_filters, kernel_size=3, batchnorm=True):
# Add First Layer
x = Conv2D(filters=n_filters, kernel_size=(kernel_size, kernel_size), kernel_initializer="he_normal",
padding="same")(input_tensor)
if batchnorm:
x = BatchNormalization()(x)
x = Activation("relu")(x)
# Add Second Layer
x = Conv2D(filters=n_filters, kernel_size=(kernel_size, kernel_size), kernel_initializer="he_normal",
padding="same")(x)
if batchnorm:
x = BatchNormalization()(x)
x = Activation("relu")(x)
return x
# Define a Function for U-Net Architecture
def vanilla_unet(input_img, n_filters=16, dropout=0.5, batchnorm=True):
# Add Contracting Path
c1 = conv2d_block(input_img, n_filters=n_filters*1, kernel_size=3, batchnorm=batchnorm)
p1 = MaxPooling2D((2, 2)) (c1)
p1 = Dropout(dropout*0.5)(p1)
c2 = conv2d_block(p1, n_filters=n_filters*2, kernel_size=3, batchnorm=batchnorm)
p2 = MaxPooling2D((2, 2)) (c2)
p2 = Dropout(dropout)(p2)
c3 = conv2d_block(p2, n_filters=n_filters*4, kernel_size=3, batchnorm=batchnorm)
p3 = MaxPooling2D((2, 2)) (c3)
p3 = Dropout(dropout)(p3)
c4 = conv2d_block(p3, n_filters=n_filters*8, kernel_size=3, batchnorm=batchnorm)
p4 = MaxPooling2D(pool_size=(2, 2)) (c4)
p4 = Dropout(dropout)(p4)
c5 = conv2d_block(p4, n_filters=n_filters*16, kernel_size=3, batchnorm=batchnorm)
# Add Expansive Path
u6 = Conv2DTranspose(n_filters*8, (3, 3), strides=(2, 2), padding='same') (c5)
u6 = concatenate([u6, c4])
u6 = Dropout(dropout)(u6)
c6 = conv2d_block(u6, n_filters=n_filters*8, kernel_size=3, batchnorm=batchnorm)
u7 = Conv2DTranspose(n_filters*4, (3, 3), strides=(2, 2), padding='same') (c6)
u7 = concatenate([u7, c3])
u7 = Dropout(dropout)(u7)
c7 = conv2d_block(u7, n_filters=n_filters*4, kernel_size=3, batchnorm=batchnorm)
u8 = Conv2DTranspose(n_filters*2, (3, 3), strides=(2, 2), padding='same') (c7)
u8 = concatenate([u8, c2])
u8 = Dropout(dropout)(u8)
c8 = conv2d_block(u8, n_filters=n_filters*2, kernel_size=3, batchnorm=batchnorm)
u9 = Conv2DTranspose(n_filters*1, (3, 3), strides=(2, 2), padding='same') (c8)
u9 = concatenate([u9, c1], axis=3)
u9 = Dropout(dropout)(u9)
c9 = conv2d_block(u9, n_filters=n_filters*1, kernel_size=3, batchnorm=batchnorm)
outputs = Conv2D(1, (1, 1), activation='sigmoid') (c9)
model = Model(inputs=[input_img], outputs=[outputs])
return model
In [16]:
# CREATE NETWORK
# Import Modules
import tensorflow as tf
from keras import backend as K
# Define a Function for Dice Coefficient Computation
def dice_coef(y_true, y_pred):
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + 1.0) / (K.sum(y_true_f) + K.sum(y_pred_f) + 1.0)
# Define a Function for Dice Coefficient Loss
def dice_coef_loss(y_true, y_pred):
return -dice_coef(y_true, y_pred)
In [17]:
# CREATE MODEL
# Instantiate Network
input_img = Input((288, 288, 3), name='img')
model = vanilla_unet(input_img, n_filters=32, dropout=0.05, batchnorm=True)
model.compile(optimizer = Adam(), loss = dice_coef_loss, metrics = ["accuracy", "binary_accuracy", "mse"])
# Print Summary
model.summary()
In [18]:
# CREATE MODEL
# Import Modules
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
# Create Callbacks
callbacks = [
EarlyStopping(patience=10, verbose=1),
ReduceLROnPlateau(factor=0.1, patience=3, min_lr=0.00001, verbose=1),
ModelCheckpoint('model-tgs-salt-dice-15-10-2018.h5', verbose=1, save_best_only=True, save_weights_only=True)
]
Set GPU Settings¶
In [19]:
# SET GPU SETTINGS
# Configure
config=tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allocator_type='BFC'
config.gpu_options.per_process_gpu_memory_fraction=0.80
Train¶
In [20]:
# TRAIN
# Train the Network
results = model.fit(x_train, y_train, batch_size=16, epochs=150, callbacks=callbacks,
validation_data=(x_valid, y_valid))
Evaluate¶
In [39]:
# EVALUATE
# Load Weights
model.load_weights('model-tgs-salt-dice-15-10-2018.h5')
# Evaluate the Model on Random Images
for i in range(100,150):
# Predict
original_image = x_valid[i]
label_image = y_valid[i]
start_time = time.time()
prediction_image = model.predict(np.expand_dims(original_image, 0))[0]
end_time = time.time()
print('Computation Time:', end_time - start_time)
# Plot
fig, (axis1, axis2, axis3) = plt.subplots(1, 3, figsize = (15,15))
original_image = resize(original_image, (200, 560), anti_aliasing=True)
label_image = resize(label_image, (200, 560), anti_aliasing=True)
prediction_image = resize(prediction_image, (200, 560), anti_aliasing=True)
axis1.imshow(original_image[:,:,0], cmap = 'jet')
axis1.set_title('Input Image')
axis2.imshow(label_image[:,:,0], cmap = 'jet')
axis2.set_title('Label')
axis3.imshow(prediction_image[:,:,0], cmap = 'jet')
axis3.set_title('Prediction')
